#region Copyright notice and license

// Copyright 2015 gRPC authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#endregion

using System;
using System.Linq;
using System.Text;
using NUnit.Framework;

namespace Grpc.Core.Tests;

public class MetadataTest
{
    [Test]
    public void AsciiEntry()
    {
        var entry = new Metadata.Entry("ABC", "XYZ");
        Assert.IsFalse(entry.IsBinary);
        Assert.AreEqual("abc", entry.Key);  // key is in lowercase.
        Assert.AreEqual("XYZ", entry.Value);
        CollectionAssert.AreEqual(new[] { (byte)'X', (byte)'Y', (byte)'Z' }, entry.ValueBytes);

        Assert.Throws(typeof(ArgumentException), () => new Metadata.Entry("abc-bin", "xyz"));

        Assert.AreEqual("[Entry: key=abc, value=XYZ]", entry.ToString());
    }

    [Test]
    public void BinaryEntry()
    {
        var bytes = new byte[] { 1, 2, 3 };
        var entry = new Metadata.Entry("ABC-BIN", bytes);
        Assert.IsTrue(entry.IsBinary);
        Assert.AreEqual("abc-bin", entry.Key);  // key is in lowercase.
        Assert.Throws(typeof(InvalidOperationException), () => { var v = entry.Value; });
        CollectionAssert.AreEqual(bytes, entry.ValueBytes);

        Assert.Throws(typeof(ArgumentException), () => new Metadata.Entry("abc", bytes));

        Assert.AreEqual("[Entry: key=abc-bin, valueBytes=System.Byte[]]", entry.ToString());
    }

    [Test]
    public void AsciiEntry_KeyValidity()
    {
        new Metadata.Entry("ABC", "XYZ");
        new Metadata.Entry("0123456789abc", "XYZ");
        new Metadata.Entry("-abc", "XYZ");
        new Metadata.Entry("a_bc_", "XYZ");
        new Metadata.Entry("abc.xyz", "XYZ");
        new Metadata.Entry("abc.xyz-bin", new byte[] {1, 2, 3});
        Assert.Throws(typeof(ArgumentException), () => new Metadata.Entry("abc[", "xyz"));
        Assert.Throws(typeof(ArgumentException), () => new Metadata.Entry("abc/", "xyz"));
    }

    [Test]
    public void KeysAreNormalized_UppercaseKey()
    {
        var uppercaseKey = "ABC";
        var entry = new Metadata.Entry(uppercaseKey, "XYZ");
        Assert.AreEqual("abc", entry.Key);
    }

    [Test]
    public void KeysAreNormalized_LowercaseKey()
    {
        var lowercaseKey = "abc";
        var entry = new Metadata.Entry(lowercaseKey, "XYZ");
        // no allocation if key already lowercase
        Assert.AreSame(lowercaseKey, entry.Key);
    }

    [Test]
    public void Entry_ConstructionPreconditions()
    {
        Assert.AreEqual("key", Assert.Throws<ArgumentNullException>(() => new Metadata.Entry(null!, "xyz"))!.ParamName);
        Assert.AreEqual("value", Assert.Throws<ArgumentNullException>(() => new Metadata.Entry("abc", (string)null!))!.ParamName);
        Assert.AreEqual("valueBytes", Assert.Throws<ArgumentNullException>(() => new Metadata.Entry("abc-bin", (byte[])null!))!.ParamName);
    }

    [Test]
    public void Entry_Immutable()
    {
        var origBytes = new byte[] { 1, 2, 3 };
        var bytes = new byte[] { 1, 2, 3 };
        var entry = new Metadata.Entry("ABC-BIN", bytes);
        bytes[0] = 255;  // changing the array passed to constructor should have any effect.
        CollectionAssert.AreEqual(origBytes, entry.ValueBytes);

        entry.ValueBytes[0] = 255;
        CollectionAssert.AreEqual(origBytes, entry.ValueBytes);
    }

    [Test]
    public unsafe void Entry_CreateUnsafe_Ascii()
    {
        var bytes = new byte[] { (byte)'X', (byte)'y' };
        fixed (byte* ptr = bytes)
        {
            var entry = Metadata.Entry.CreateUnsafe("abc", new IntPtr(ptr), bytes.Length);
            Assert.IsFalse(entry.IsBinary);
            Assert.AreEqual("abc", entry.Key);
            Assert.AreEqual("Xy", entry.Value);
            CollectionAssert.AreEqual(bytes, entry.ValueBytes);
        }
    }

    [Test]
    public unsafe void Entry_CreateUnsafe_Binary()
    {
        var bytes = new byte[] { 1, 2, 3 };
        fixed (byte* ptr = bytes)
        {
            var entry = Metadata.Entry.CreateUnsafe("abc-bin", new IntPtr(ptr), bytes.Length);
            Assert.IsTrue(entry.IsBinary);
            Assert.AreEqual("abc-bin", entry.Key);
            Assert.Throws(typeof(InvalidOperationException), () => { var v = entry.Value; });
            CollectionAssert.AreEqual(bytes, entry.ValueBytes);
        }
    }

    [Test]
    public void IndexOf()
    {
        var metadata = CreateMetadata();
        Assert.AreEqual(0, metadata.IndexOf(metadata[0]));
        Assert.AreEqual(1, metadata.IndexOf(metadata[1]));
    }

    [Test]
    public void Insert()
    {
        var metadata = CreateMetadata();
        metadata.Insert(0, new Metadata.Entry("new-key", "new-value"));
        Assert.AreEqual(3, metadata.Count);
        Assert.AreEqual("new-key", metadata[0].Key);
        Assert.AreEqual("abc", metadata[1].Key);
    }

    [Test]
    public void RemoveAt()
    {
        var metadata = CreateMetadata();
        metadata.RemoveAt(0);
        Assert.AreEqual(1, metadata.Count);
        Assert.AreEqual("xyz", metadata[0].Key);
    }

    [Test]
    public void Remove()
    {
        var metadata = CreateMetadata();
        metadata.Remove(metadata[0]);
        Assert.AreEqual(1, metadata.Count);
        Assert.AreEqual("xyz", metadata[0].Key);
    }

    [Test]
    public void Indexer_Set()
    {
        var metadata = CreateMetadata();
        var entry = new Metadata.Entry("new-key", "new-value");

        metadata[1] = entry;
        Assert.AreEqual(entry, metadata[1]);
    }

    [Test]
    public void Clear()
    {
        var metadata = CreateMetadata();
        metadata.Clear();
        Assert.AreEqual(0, metadata.Count);
    }

    [Test]
    public void Contains()
    {
        var metadata = CreateMetadata();
        Assert.IsTrue(metadata.Contains(metadata[0]));
        Assert.IsFalse(metadata.Contains(new Metadata.Entry("new-key", "new-value")));
    }

    [Test]
    public void CopyTo()
    {
        var metadata = CreateMetadata();
        var array = new Metadata.Entry[metadata.Count + 1];

        metadata.CopyTo(array, 1);
        Assert.AreEqual(default(Metadata.Entry), array[0]);
        Assert.AreEqual(metadata[0], array[1]);
    }

    [Test]
    public void IEnumerableGetEnumerator()
    {
        var metadata = CreateMetadata();
        var enumerator = (metadata as System.Collections.IEnumerable).GetEnumerator();

        int i = 0;
        while (enumerator.MoveNext())
        {
            Assert.AreEqual(metadata[i], enumerator.Current);
            i++;
        }
    }

    [Test]
    public void FreezeMakesReadOnly()
    {
        var entry = new Metadata.Entry("new-key", "new-value");
        var metadata = CreateMetadata().Freeze();

        Assert.IsTrue(metadata.IsReadOnly);
        Assert.Throws<InvalidOperationException>(() => metadata.Insert(0, entry));
        Assert.Throws<InvalidOperationException>(() => metadata.RemoveAt(0));
        Assert.Throws<InvalidOperationException>(() => metadata[0] = entry);
        Assert.Throws<InvalidOperationException>(() => metadata.Add(entry));
        Assert.Throws<InvalidOperationException>(() => metadata.Add("new-key", "new-value"));
        Assert.Throws<InvalidOperationException>(() => metadata.Add("new-key-bin", new byte[] { 0xaa }));
        Assert.Throws<InvalidOperationException>(() => metadata.Clear());
        Assert.Throws<InvalidOperationException>(() => metadata.Remove(metadata[0]));
    }

    [Test]
    public void GetAll()
    {
        var metadata = new Metadata
        {
            { "abc", "abc-value1" },
            { "abc", "abc-value2" },
            { "xyz", "xyz-value1" },
        };

        var abcEntries = metadata.GetAll("abc").ToList();
        Assert.AreEqual(2, abcEntries.Count);
        Assert.AreEqual("abc-value1", abcEntries[0].Value);
        Assert.AreEqual("abc-value2", abcEntries[1].Value);

        var xyzEntries = metadata.GetAll("xyz").ToList();
        Assert.AreEqual(1, xyzEntries.Count);
        Assert.AreEqual("xyz-value1", xyzEntries[0].Value);

        var xyzUppercaseEntries = metadata.GetAll("XYZ").ToList();
        Assert.AreEqual(1, xyzUppercaseEntries.Count);
        Assert.AreEqual("xyz-value1", xyzUppercaseEntries[0].Value);
    }

    [Test]
    public void Get()
    {
        var metadata = new Metadata
        {
            { "abc", "abc-value1" },
            { "abc", "abc-value2" },
            { "xyz", "xyz-value1" },
        };

        var abcEntry = metadata.Get("abc");
        Assert.NotNull(abcEntry);
        Assert.AreEqual("abc-value2", abcEntry!.Value);

        var xyzEntry = metadata.Get("xyz");
        Assert.NotNull(xyzEntry);
        Assert.AreEqual("xyz-value1", xyzEntry!.Value);

        var abcUppercaseEntry = metadata.Get("AbC");
        Assert.NotNull(abcUppercaseEntry);
        Assert.AreEqual("abc-value2", abcUppercaseEntry!.Value);

        var notFound = metadata.Get("not-found");
        Assert.AreEqual(null, notFound);

    }

    [Test]
    public void GetValue()
    {
        var metadata = new Metadata
        {
            { "abc", "abc-value1" },
            { "abc", "abc-value2" },
            { "xyz", "xyz-value1" },
            { "xyz-bin", Encoding.ASCII.GetBytes("xyz-value1") },
        };

        var abcValue = metadata.GetValue("abc");
        Assert.AreEqual("abc-value2", abcValue);

        var xyzValue = metadata.GetValue("xyz");
        Assert.AreEqual("xyz-value1", xyzValue);

        var abcUppercaseValue = metadata.GetValue("ABC");
        Assert.AreEqual("abc-value2", abcUppercaseValue);

        var notFound = metadata.GetValue("not-found");
        Assert.AreEqual(null, notFound);
    }

    [Test]
    public void GetValue_BytesValue()
    {
        var metadata = new Metadata
        {
            { "xyz-bin", Encoding.ASCII.GetBytes("xyz-value1") },
        };

        Assert.Throws<InvalidOperationException>(() => metadata.GetValue("xyz-bin"));
    }

    [Test]
    public void GetValueBytes()
    {
        var metadata = new Metadata
        {
            { "abc-bin", Encoding.ASCII.GetBytes("abc-value1") },
            { "abc-bin", Encoding.ASCII.GetBytes("abc-value2") },
            { "xyz-bin", Encoding.ASCII.GetBytes("xyz-value1") },
        };

        var abcValue = metadata.GetValueBytes("abc-bin");
        Assert.AreEqual(Encoding.ASCII.GetBytes("abc-value2"), abcValue);

        var xyzValue = metadata.GetValueBytes("xyz-bin");
        Assert.AreEqual(Encoding.ASCII.GetBytes("xyz-value1"), xyzValue);

        var xyzUppercaseValue = metadata.GetValueBytes("XYZ-BIN");
        Assert.AreEqual(Encoding.ASCII.GetBytes("xyz-value1"), xyzUppercaseValue);

        var notFound = metadata.GetValueBytes("not-found");
        Assert.AreEqual(null, notFound);
    }

    [Test]
    public void GetValueBytes_StringValue()
    {
        var metadata = new Metadata
        {
            { "xyz", "xyz-value1" },
        };

        var xyzValue = metadata.GetValueBytes("xyz");
        Assert.AreEqual(Encoding.ASCII.GetBytes("xyz-value1"), xyzValue);
    }

    private Metadata CreateMetadata()
    {
        return new Metadata
        {
            { "abc", "abc-value" },
            { "xyz", "xyz-value" },
        };
    }
}
